- We fail to exit early when following the version chain with both
  LOAD_DOWNTO and LOAD_FROM_TIME. Adds a cpp test to show that
- Fix will be done in follow up commits

- Before this change we had to remember to update the version_map entry
  every time after calling write_tombstone. Now write_tombstone does it
internally.
- This is a small change which should not affect behavior.
- Tests are not updated regarding this change because they will be
  revamped in following commmits.

- Unify loaded_until_ and oldest_loaded_index_version_ as they should
  always have the same version (because version chain is sorted)
- Store a LoadProgress inside VersionMapEntry instead of a loaded_until
- The LoadProgress has information about earliest loaded version and
  earliest loaded timestamp. This allows us to resolve the TODOs inside
the has_cached_entry checks.
- Now we can always determine whether LOAD_FROM_TIME needs to read from
  cache by comparing with the LoadProgress timestamp.
- Revamps CacheInvalidation cpp tests to cover the new functionality
- Add an earliest_loaded_undeleted_timestamp to make follow up refactor
  easier.
- Makes the refactor in follow up commit easier to reason about.

- We keep an oldest_loaded_undeleted_index_version in the LoadProgress
- We use it so that if we tombstone that version (either by a tombstone
  or tombstone_all) we invalidate the cache for undeleted versions

Introduces a new type LoadStrategy which has the load_type, the
to_load enum, which indicates whether to load ANY or only UNDELETED
versions and the version/time we need to search for.

With this commit we mostly preserve existing behavior with a few
exceptions:
- The newly introduced deleted/undeleted variants of LOAD_DOWNTO and LOAD_FROM_TIME are introduced and are handled appropriately and their behavior is documented in LoadStrategy.
- Abstract away the batch version map merging of LoadStrategies and fix
  a small bug there.
- Fixes #1386 by passing include_deleted=false when looking for as_of
  time or version

Also adds an elaborate FollowingVersionChain and
FollowingVersionChainWithCaching cpp tests

- Shouldn't change behavior.

Before this change version_map's reload_interval was equal to the
unsync_tolerance. This means that we would ~always miss the cache.

The check for outdated cache is as follows:
- When reading into cache set `last_reload_time = now -
  unsync_tolerance`
- When checking if cache is outdated we check whether `now -
  last_reload_time > reload_interval

This change updates the unsync tolerance to 200ms. This will mean the
cache is valid for 1.8s

Tests uncovered that we were not flushing the version_map when clearing
the storage. This change fixes this as well.

This commit is only a rename

`iterate_on_failure` used to provide a back up way to load versions if
the ref key is unreadable for some reason. The ref key should no longer
be unreadable, thus `iterate_on_failure` should be removed.

This commit removes the `iterate_on_failure`
- argument in the `lib._nvs` functions
- parameter of `VersionQuery`
- parameter of `LoadParameter` and entirely removes the `LoadParameter`
  and replaces it with `LoadStrategy`
- removes IterateOnFailure cpp test which used to test this behavior by
  artificially removing the ref key.

The lib._nvs api needs to be stable so we re-add the iterate_on_failure
argument to not break existing usage.

Instead whenever the argument is passed we issue a warning that it's
deprecated.

This commit is just a rename addressing some code review comments.